/**
 * 模型配置文件辅助函数
 * 每个模型独立保存配置文件，无需索引文件
 */

const fs = require('fs').promises;
const fsSync = require('fs');
const path = require('path');

/**
 * 读取单个模型的完整配置
 * @param {string} modelsDir - 模型目录路径
 * @param {string} modelId - 模型ID
 * @returns {Promise<Object|null>} 模型配置对象，如果不存在返回null
 */
async function readModelConfig(modelsDir, modelId) {
    const configPath = path.join(modelsDir, `${modelId}.json`);
    
    try {
        const data = await fs.readFile(configPath, 'utf-8');
        return JSON.parse(data);
    } catch (error) {
        return null;
    }
}

/**
 * 写入单个模型的完整配置
 * @param {string} modelsDir - 模型目录路径
 * @param {string} modelId - 模型ID
 * @param {Object} modelData - 模型配置数据
 */
async function writeModelConfig(modelsDir, modelId, modelData) {
    const configPath = path.join(modelsDir, `${modelId}.json`);
    modelData.updatedAt = new Date().toISOString();
    await fs.writeFile(configPath, JSON.stringify(modelData, null, 2), 'utf-8');
}

/**
 * 删除单个模型的配置文件
 * @param {string} modelsDir - 模型目录路径
 * @param {string} modelId - 模型ID
 */
async function deleteModelConfig(modelsDir, modelId) {
    const configPath = path.join(modelsDir, `${modelId}.json`);
    
    try {
        await fs.unlink(configPath);
    } catch (error) {
        // 文件可能不存在，忽略错误
    }
}

/**
 * 获取所有模型的完整配置（从各自的配置文件）
 * @param {string} modelsDir - 模型目录路径
 * @returns {Promise<Array>} 模型配置数组
 */
async function getAllModels(modelsDir) {
    try {
        // 确保目录存在
        if (!fsSync.existsSync(modelsDir)) {
            return [];
        }
        
        // 读取目录中的所有文件
        const files = await fs.readdir(modelsDir);
        const models = [];
        
        // 遍历所有 .json 文件（排除 models.json 如果存在）
        for (const file of files) {
            if (file.endsWith('.json') && file !== 'models.json') {
                try {
                    const configPath = path.join(modelsDir, file);
                    const data = await fs.readFile(configPath, 'utf-8');
                    const modelConfig = JSON.parse(data);
                    models.push(modelConfig);
                } catch (error) {
                    console.warn(`⚠️ 读取模型配置失败 (${file}):`, error.message);
                }
            }
        }
        
        // 按创建时间排序
        models.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
        
        return models;
    } catch (error) {
        console.error('❌ 获取模型列表失败:', error);
        return [];
    }
}

/**
 * 获取所有标签
 * @param {string} modelsDir - 模型目录路径
 * @returns {Promise<Array>} 标签数组
 */
async function getAllTags(modelsDir) {
    const models = await getAllModels(modelsDir);
    const tagsSet = new Set();
    
    for (const model of models) {
        if (model.tags && Array.isArray(model.tags)) {
            model.tags.forEach(tag => {
                if (tag && typeof tag === 'string') {
                    tagsSet.add(tag.trim());
                }
            });
        }
    }
    
    return Array.from(tagsSet).sort();
}

module.exports = {
    readModelConfig,
    writeModelConfig,
    deleteModelConfig,
    getAllModels,
    getAllTags
};

